<!DOCTYPE html>
<html>
  <head>
    <title>
      offlineaudiocontext-suspend-resume-basic.html
    </title>
    <script src="../../resources/testharness.js"></script>
    <script src="../../resources/testharnessreport.js"></script>
    <script src="../resources/audit-util.js"></script>
    <script src="../resources/audit.js"></script>
  </head>
  <body>
    <script id="layout-test-code">
      let sampleRate = 44100;
      let renderDuration = 1;
      let renderQuantum = 128;

      let audit = Audit.createTaskRunner();

      // Task: Calling suspend with no argument, negative time or the time
      // beyond the maximum render duration reject the promise.
      audit.define('suspend-invalid-argument', (task, should) => {
        let context =
            new OfflineAudioContext(1, sampleRate * renderDuration, sampleRate);

        should(context.suspend(), 'context.suspend()').beRejected();
        should(context.suspend(-1.0), 'context.suspend(-1.0)').beRejected();
        should(context.suspend(2.0), 'context.suspend(2.0)').beRejected();

        context.startRendering().then(() => task.done());
      });

      // Task: Scheduling a suspend in the past should be rejected.
      audit.define('suspend-in-the-past', (task, should) => {
        let context =
            new OfflineAudioContext(1, sampleRate * renderDuration, sampleRate);

        context.suspend(0.5).then(function() {
          should(
              context.suspend(context.currentTime - 0.1),
              'Scheduling a suspend in the past')
              .beRejected();

          should(context
                     .suspend(
                         context.currentTime + 0.1,
                         'Scheduling a suspend in the future')
                     .then(function() {
                       context.resume();
                     }))
              .beResolved();

          context.resume();
        });

        context.startRendering().then(() => task.done());
      });

      // Task: suspending after rendering is finished must be rejected with the
      // properly clamped frame/time information.
      audit.define('suspend-after-render-completion', (task, should) => {
        let context =
            new OfflineAudioContext(1, sampleRate * renderDuration, sampleRate);
        context.startRendering()
            .then(function() {
              should(
                  context.suspend(renderDuration),
                  'Scheduling a suspend after the render completion')
                  .beRejected();
            })
            .then(() => task.done());
      });

      // Task: Calling multiple suspends at the same rendering quantum should
      // reject the promise.
      audit.define('identical-suspend-time', (task, should) => {
        let context =
            new OfflineAudioContext(1, sampleRate * renderDuration, sampleRate);

        // |suspendTime1| and |suspendTime2| are identical when quantized to the
        // render quantum size.  The factors are arbitrary except they should be
        // between 1 (exclusive) and 2 (inclusive).  Using a factor of 2 also
        // tests that times are rounded up.
        let suspendTime1 = 1.25 * renderQuantum / sampleRate;
        let suspendTime2 = 2 * renderQuantum / sampleRate;

        should(
            () => context.suspend(suspendTime1).then(() => context.resume()),
            'Scheduling a suspend at frame ' + suspendTime1 * sampleRate)
            .notThrow();

        should(
            context.suspend(suspendTime2).then(() => context.resume()),
            'Scheduling another suspend at the same rendering quantum')
            .beRejected();

        context.startRendering().then(() => task.done());
      });

      // Task: Resuming a running context should be resolved.
      audit.define('resume-before-suspend', (task, should) => {
        // Make the render length 5 times longer to minimize the flakiness.
        let longRenderDuration = renderDuration * 5;
        let context = new OfflineAudioContext(
            1, sampleRate * longRenderDuration, sampleRate);

        // Create dummy audio graph to slow the rendering.
        let osc = context.createOscillator();
        let lpf = context.createBiquadFilter();
        osc.type = 'sawtooth';
        osc.frequency.setValueAtTime(0.1, 0.0);
        osc.frequency.linearRampToValueAtTime(1000, longRenderDuration * 0.5);
        osc.frequency.linearRampToValueAtTime(0.1, longRenderDuration);
        lpf.frequency.setValueAtTime(0.1, 0.0);
        lpf.frequency.linearRampToValueAtTime(1000, longRenderDuration * 0.5);
        lpf.frequency.linearRampToValueAtTime(0.1, longRenderDuration);
        osc.connect(lpf);
        lpf.connect(context.destination);
        osc.start();

        // A suspend is scheduled at the 90% of the render duration.
        should(
            () => {
              // Test is finished when this suspend resolves.
              context.suspend(longRenderDuration * 0.9).then(() => task.done());
            },
            'Scheduling a suspend at ' + longRenderDuration * 0.9 + ' seconds')
            .notThrow();

        // We have to start rendering to get the time running.
        context.startRendering();

        // Then call resume() immediately after the rendering starts. Resuming
        // a context that is already running should be resolved.
        should(context.resume(), 'Resuming a running context').beResolved();
      });

      // Task: Calling resume on a context that is not started should reject the
      // promise.
      audit.define('resume-without-suspend', (task, should) => {
        let context =
            new OfflineAudioContext(1, sampleRate * renderDuration, sampleRate);

        should(context.resume(), 'Resuming a context without starting it')
            .beRejected()
            .then(() => task.done());
      });

      audit.run();
    </script>
  </body>
</html>
